home *** CD-ROM | disk | FTP | other *** search
/ FM Towns: Free Software Collection 6 / FM Towns Free Software Collection 6.iso / t_os / et / src / buffer.c < prev    next >
Text File  |  1993-07-08  |  10KB  |  319 lines
  1. #include  "et.h"
  2. int   copy_buffer(int file_i, int mm, int *np, int replay_n)/*et*/
  3. {
  4.   FILE  *File, *Temp;
  5.   int   i, dummy;
  6.   int   key_n, csr_n;
  7.   unsigned  f, m;
  8.   DIR   Dir[1];
  9.   
  10.   if (test_bit(G_f, f_DEMO|f_MAKE))
  11.     return;
  12.   switch(mm) {
  13.   case STORE:
  14.     if (file_i >= 4) {
  15.       G_nb.drive = *P_c[c_FILE_REPLAY];
  16.       switch(file_i) {
  17.       case 4:
  18.         f = f_REPLAY;
  19.         File = et_fopen(P_c[c_FILE_REPLAY], "wb", NULL);
  20.         et_fwrite(&f, sizeof(unsigned), 1, File);
  21.         et_fwrite(&dummy, sizeof(long), 1, File);
  22.         break;
  23.       case 5:
  24.         f = f_ERR;
  25.         File = et_fopen(P_c[c_FILE_REPLAY], "wb", NULL);
  26.         et_fwrite(&f, sizeof(unsigned), 1, File);
  27.         et_fwrite(&dummy, sizeof(long), 1, File);
  28.         break;
  29.       case 6:
  30.         f = f_ERR;
  31.         File = et_fopen(P_c[c_FILE_REPLAY], "ab", NULL);
  32.         fseek(File, 0L, 0);
  33.         et_fwrite(&f, sizeof(unsigned), 1, File);
  34.         et_fwrite(&replay_n, sizeof(long), 1, File);
  35.         _far_copy_buf(0x120, G_bf.pna, 0x14, P_v[v_VRAM], 0xa000);
  36.         et_fwrite(P_v[v_VRAM], 1, 0xa000, File);
  37.         et_fwrite(&G_pn.pna, sizeof(DIR*), 1, File);
  38.         et_fwrite(P_i[i_PNA_N], sizeof(int), 30, File);
  39.         et_fwrite(P_i[i_PNA_I], sizeof(int), 30, File);
  40.         fseek(File, replay_n, 0);
  41.         et_fwrite(&f, sizeof(unsigned), 1, File);
  42.         et_fwrite(&dummy, sizeof(long), 1, File);
  43.         break;
  44.       }
  45.       et_fwrite(P_v[v_VRAM], 1, 0xa000+sizeof(DIR*)+sizeof(int)*30*2,File);
  46.       et_fwrite(&G_nb.key, sizeof(int), 1, File);
  47.       et_fwrite(&G_nb.csr, sizeof(int), 1, File);
  48.     } else {
  49.       set_file_i(&P_c[c_FILE_BAK][8], file_i);
  50.       File = et_fopen(P_c[c_FILE_BAK], "wb", NULL);
  51.       G_nb.drive = *P_c[c_FILE_BAK];
  52.     }
  53.     f = test_bit(G_f, f_TROFF|f_AA|f_NN|f_REV|f_RND|f_VIEW|f_RR);
  54.     et_fwrite(&f, sizeof(G_f), 1, File);
  55.     et_fwrite(&G_nb.edge, sizeof(int), 1, File);
  56.     et_fwrite(G_et, sizeof(ET), G_nb.edge, File);
  57.     et_fwrite(G_edge, sizeof(EDGE), G_nb.edge, File);
  58.     et_fwrite(G_bf.edge, sizeof(EDGE), G_nb.edge, File);
  59.     key_n = nb_key(G_mv);
  60.     et_fwrite(&key_n, sizeof(int), 1, File);
  61.     et_fwrite(G_mv, sizeof(MOVE), key_n+1, File);
  62.     csr_n = nb_csr(P_c[c_CSR]);
  63.     et_fwrite(&csr_n, sizeof(int), 1, File);
  64.     et_fwrite(P_c[c_CSR], 1, csr_n+1, File);
  65.     et_fwrite(&G_pm, sizeof(PARAMETER), 1, File);
  66.     et_fwrite(&G_ps, sizeof(POSITION), 1, File);
  67.     et_fwrite(&G_nb.key_i, sizeof(int), 1, File);
  68.     if (file_i < 4) {
  69.       fclose(File);
  70.       return(0L);
  71.     }
  72.     et_fwrite(&G_nb.pna_drive, sizeof(int), 1, File);
  73.     et_fwrite(G_id, sizeof(IDX), 64, File);
  74.     et_fwrite(np, sizeof(int), 1, File);
  75.     if (G_nb.key) {
  76.       Temp = et_fopen(P_c[c_FILE_ICN_KEY], "rb", File);
  77.       copy_file(File, Temp, (int)G_nb.key * P_i[i_SIZE_ICN][0]);
  78.       fclose(Temp);
  79.     }
  80.     if (G_nb.csr) {
  81.       Temp = et_fopen(P_c[c_FILE_ICN_CSR], "rb", File);
  82.       copy_file(File, Temp, (int)G_nb.csr * P_i[i_SIZE_ICN][0]);
  83.       fclose(Temp);
  84.     }
  85.     set_file_i(&P_c[c_FILE_BAK][8], 0);
  86.     Temp = fopen(P_c[c_FILE_BAK], "rb");
  87.     if (!Temp) {
  88.       m = 0;
  89.       et_fwrite(&m, sizeof(int), 1, File);
  90.     } else {
  91.       fseek(Temp, 0L, 2);
  92.       m = ftell(Temp);
  93.       fseek(Temp, 0L, 0);
  94.       et_fwrite(&m, sizeof(int), 1, File);
  95.       copy_file(File, Temp, m);
  96.       fclose(Temp);
  97.     }
  98.     m = ftell(File);
  99.     fclose(File);
  100.     return(m);
  101.     break;
  102.   case RESTORE:
  103.     if (file_i >= 4) {
  104.       File = et_fopen(P_c[c_FILE_REPLAY], "rb", NULL);
  105.       fread(&dummy, sizeof(unsigned), 1, File);
  106.       if (file_i == 6) {
  107.         fread(&replay_n, sizeof(int), 1, File);
  108.         fseek(File, replay_n, 0L);
  109.         fread(&dummy, sizeof(unsigned), 1, File);
  110.         fread(&dummy, sizeof(unsigned), 1, File);
  111.       } else
  112.         fread(&dummy, sizeof(int), 1, File);
  113.       if (file_i == 4) {
  114.         fread(P_v[v_VRAM], 1, 0xa000, File);
  115.         _far_copy_buf(0x14, P_v[v_VRAM], 0x120, G_bf.pna, 0xa000);
  116.         fread(&G_pn.pna, sizeof(DIR*), 1, File);
  117.         fread(P_i[i_PNA_N], sizeof(int), 30, File);
  118.         fread(P_i[i_PNA_I], sizeof(int), 30, File);
  119.       } else {
  120.         fread(P_v[v_VRAM], 1, 0xa000+sizeof(DIR*)+sizeof(int)*30*2, File);
  121.         for (i = 0; i < 30; i++)
  122.           P_i[i_PNA_N][i] = -1;
  123.         Dir->dir = NULL;
  124.         Dir->next = NULL;
  125.         poke_dir(Dir, G_bf.pna);
  126.         G_pn.pna = (char*)G_bf.pna;
  127.       }
  128.       fread(&G_nb.key, sizeof(int), 1, File);
  129.       fread(&G_nb.csr, sizeof(int), 1, File);
  130.     } else {
  131.       set_file_i(&P_c[c_FILE_BAK][8], file_i);
  132.       File = et_fopen(P_c[c_FILE_BAK], "rb", NULL);
  133.     }
  134.     fread(&f, sizeof(G_f), 1, File);
  135.     res_bit(G_f, f_TROFF|f_AA|f_NN|f_REV|f_RND|f_VIEW|f_RR);
  136.     set_bit(G_f, f);
  137.     shaff_dot(P_dot[dot_FREE_AREA]);
  138.     shaff_dot(P_dot[dot_FREE_SAVE]);
  139.     copy_dot(P_dot[dot_FREE_WORK], P_dot[dot_FREE_SAVE]);
  140.     fread(&G_nb.edge, sizeof(int), 1, File);
  141.     if (G_nb.edge > G_nb.max_edge) {
  142.       int   i_max;
  143.       i_max = sizeof(ET)*(G_nb.edge-G_nb.max_edge);
  144.       fread(G_et, sizeof(ET), G_nb.max_edge, File);
  145.       while (i_max--)
  146.         fgetc(File);
  147.       i_max = sizeof(EDGE)*(G_nb.edge-G_nb.max_edge);
  148.       fread(G_edge, sizeof(EDGE), G_nb.max_edge, File);
  149.       while (i_max--)
  150.         fgetc(File);
  151.       i_max = sizeof(EDGE)*(G_nb.edge-G_nb.max_edge);
  152.       fread(G_bf.edge, sizeof(EDGE), G_nb.max_edge, File);
  153.       while (i_max--)
  154.         fgetc(File);
  155.       G_nb.edge = G_nb.max_edge;
  156.     } else {
  157.       fread(G_et, sizeof(ET), G_nb.edge, File);
  158.       fread(G_edge, sizeof(EDGE), G_nb.edge, File);
  159.       fread(G_bf.edge, sizeof(EDGE), G_nb.edge, File);
  160.     }
  161.     fread(&key_n, sizeof(int), 1, File);
  162.     fread(G_mv, sizeof(MOVE), key_n+1, File);
  163.     fread(&csr_n, sizeof(int), 1, File);
  164.     fread(P_c[c_CSR], 1, csr_n+1, File);
  165.     fread(&G_pm, sizeof(PARAMETER), 1, File);
  166.     fread(&G_ps, sizeof(POSITION), 1, File);
  167.     fread(&G_nb.key_i, sizeof(int), 1, File);
  168.     G_pn.csr = P_c[c_CSR] + csr_n-1;
  169.     G_nb.et = *G_pn.csr;
  170.     if (file_i < 4) {
  171.       fclose(File);
  172.       return(0);
  173.     }
  174.     fread(&G_nb.pna_drive, sizeof(int), 1, File);
  175.     fread(G_id, sizeof(IDX), 64, File);
  176.     fread(np, sizeof(int), 1, File);
  177.     Temp = et_fopen(P_c[c_FILE_ICN_KEY], "wb", File);
  178.     if (G_nb.key) {
  179.       G_nb.drive = *P_c[c_FILE_ICN_KEY];
  180.       copy_file(Temp, File, (int)G_nb.key * P_i[i_SIZE_ICN][0]);
  181.     }
  182.     fclose(Temp);
  183.     Temp = et_fopen(P_c[c_FILE_ICN_CSR], "wb", File);
  184.     if (G_nb.csr) {
  185.       G_nb.drive = *P_c[c_FILE_ICN_CSR];
  186.       copy_file(Temp, File, (int)G_nb.csr * P_i[i_SIZE_ICN][0]);
  187.     }
  188.     fclose(Temp);
  189.     set_file_i(&P_c[c_FILE_BAK][8], 0);
  190.     Temp = et_fopen(P_c[c_FILE_BAK], "wb", File);
  191.     G_nb.drive = *P_c[c_FILE_BAK];
  192.     fread(&m, sizeof(int), 1, File);
  193.     copy_file(Temp, File, m);
  194.     m = ftell(File);
  195.     fclose(Temp);
  196.     fclose(File);
  197.     return(m);
  198.     break;
  199.   }
  200. }
  201. void  copy_window(int pq_a[], VRAM buf_p[], unsigned seg, int mm)/*et*/
  202. {
  203.   int   p_i, q_i, p_d, p_n;
  204.   VRAM  *vram_p;
  205.   
  206.   p_i = pq_a[0];
  207.   q_i = pq_a[1];
  208.   p_d = (pq_a[2] - pq_a[0]) / 8 * sizeof(VRAM);
  209.   p_n = p_d / sizeof(VRAM);
  210.   vram_p = vram_addr(p_i, q_i, !G_nb.page);
  211.   switch(mm) {
  212.   case POKE:
  213.     while (1) {
  214.       _far_copy_buf(seg, buf_p, 0x120, vram_p, p_d);
  215.       vram_p += Y_INC;
  216.       q_i++;
  217.       if (q_i < pq_a[3])
  218.         buf_p += p_n;
  219.       else
  220.         break;
  221.     }
  222.     break;
  223.   case PEEK:
  224.     while (1) {
  225.       _far_copy_buf(0x120, vram_p, seg, buf_p, p_d);
  226.       vram_p += Y_INC;
  227.       q_i++;
  228.       if (q_i < pq_a[3])
  229.         buf_p += p_n;
  230.       else
  231.         break;
  232.     }
  233.     break;
  234.   }
  235. }
  236. void  copy_edge(int rs_m, int ab_m)/*et*/
  237. {
  238.   char  *buf1_p, *buf2_p;
  239.   int   edge_n;
  240.   
  241.   buf1_p = G_bf.et_buf;
  242.   buf2_p = (char*)((int)G_bf.et_buf + sizeof(EDGE) * G_nb.max_edge);
  243.   switch(ab_m) {
  244.   case AFT:
  245.     edge_n = G_nb.edge;
  246.     break;
  247.   case BEF:
  248.     edge_n = G_nb.edge_b;
  249.     break;
  250.   }
  251.   switch(rs_m) {
  252.   case STORE:
  253.     _copy_buf(buf1_p, G_edge, sizeof(EDGE) * edge_n);
  254.     _copy_buf(buf2_p, G_bf.edge, sizeof(EDGE) * edge_n);
  255.     break;
  256.   case RESTORE:
  257.     _copy_buf(G_edge, buf1_p, sizeof(EDGE) * edge_n);
  258.     _copy_buf(G_bf.edge, buf2_p, sizeof(EDGE) * edge_n);
  259.     break;
  260.   case EXCHANGE:
  261.     _copy_buf(G_bf.edge_buf, G_edge, sizeof(EDGE) * G_nb.edge);
  262.     _copy_buf(G_edge, buf1_p, sizeof(EDGE) * G_nb.edge);
  263.     _copy_buf(buf1_p, G_bf.edge_buf, sizeof(EDGE) * G_nb.edge);
  264.     _copy_buf(G_bf.edge_buf, G_bf.edge, sizeof(EDGE) * G_nb.edge);
  265.     _copy_buf(G_bf.edge, buf2_p, sizeof(EDGE) * G_nb.edge);
  266.     _copy_buf(buf2_p, G_bf.edge_buf, sizeof(EDGE) * G_nb.edge);
  267.     break;
  268.   }
  269. }
  270. void  load_vram(int offs, VRAM *vram_p, int size)/*et*/
  271. {               /* v_KEY_TMP をバッファに使用 */
  272.   FILE  *File;
  273.   char  *c_p;
  274.   int   i, j;
  275.   
  276.   if (test_bit(G_f, f_DEMO))
  277.     return;
  278.   j = sizeof(VRAM[BUF_SIZE*2]);
  279.   set_file_i(&P_c[c_FILE_BAK][8], 3);
  280.   File = et_fopen(P_c[c_FILE_BAK], "rb", NULL);
  281.   c_p = (char*)vram_p;
  282.   while (size > 0) {
  283.     if (size < j)
  284.       i = size;
  285.     else
  286.       i = j;
  287.     fread(P_v[v_KEY_TMP], 1, i, File);
  288.     _memcpyfar(0x14, P_v[v_KEY_TMP], offs, c_p, i);
  289.     size -= j;
  290.     c_p += j;
  291.   }
  292.   fclose(File);
  293. }
  294. void  save_vram(int offs, VRAM *vram_p, int size)/*et*/
  295. {               /* v_KEY_TMP をバッファに使用 */
  296.   FILE  *File;
  297.   char  *c_p;
  298.   int   i, j;
  299.   
  300.   if (test_bit(G_f, f_DEMO))
  301.     return;
  302.   j = sizeof(VRAM[BUF_SIZE*2]);
  303.   set_file_i(&P_c[c_FILE_BAK][8], 3);
  304.   File = et_fopen(P_c[c_FILE_BAK], "wb", NULL);
  305.   G_nb.drive = *P_c[c_FILE_BAK];
  306.   c_p = (char*)vram_p;
  307.   while (size > 0) {
  308.     if (size < j)
  309.       i = size;
  310.     else
  311.       i = j;
  312.     _memcpyfar(offs, c_p, 0x14, P_v[v_KEY_TMP], i);
  313.     et_fwrite(P_v[v_KEY_TMP], 1, i, File);
  314.     size -= j;
  315.     c_p += j;
  316.   }
  317.   fclose(File);
  318. }
  319.